let selectedDate = new Date();
let currentPlans = JSON.parse(localStorage.getItem('dailyPlans')) || {};
let editingPlanKey = null;
// 添加运动计划时，选择的下拉计划标题
const suggestedTitles = ["饮食计划","全身热身", "HIIT训练", "力量训练", "有氧训练", "核心训练", "拉伸放松", "户外运动", "球类运动"];
// 初始化
document.addEventListener('DOMContentLoaded', () => {
    const monthPicker = document.getElementById('month-picker'); // 月份选择器
    const today = new Date();
    const year = today.getFullYear();
    const month = String(today.getMonth() + 1).padStart(2, '0');
    monthPicker.value = `${year}-${month}`;

    updateCurrentDateInfo(); // 初始化当前时间信息（年月日、星期、本周的开始和结束时间）
    renderCalendar(); // 初始化日历，默认是当前月份的日历

    // 月份选择器绑定事件
    monthPicker.addEventListener('change', (e) => {
        const [y, m] = e.target.value.split('-').map(Number);
        selectedDate = new Date(y, m - 1);
        renderCalendar(); // 选择月份时，重新渲染日历
    });
    // 这里当点击弹框以外的任意位置，关闭弹框
    /*document.getElementById('plan-modal').addEventListener('click', (e) => {
        if (e.target.id === 'plan-modal') closeModal();
    });*/
    document.querySelector('.close-btn').addEventListener('click', closeModal); // 关闭弹框
    populateTitleSuggestions(); // 加载计划标题下拉
    // 监听来自倒计时页面的消息
    window.addEventListener('message', (event) => {
        if (event.data.type === 'EXERCISE_COMPLETED') {
            renderCalendar(); // 重新渲染，更新计划状态
        }
    });
});

/**
 * 切换月份
 * @param isNext 是否是下一个月 true 下一个月 false 上一个月
 */
function updateMonth(isNext){
    const monthPicker = document.getElementById('month-picker'); // 月份选择器
    // 获取当前选中的月份，格式为 "YYYY-MM"
    const currentMonth = monthPicker.value;
    if (!currentMonth) return; // 如果没有值，直接返回
    // 解析年份和月份
    const [yearStr, monthStr] = currentMonth.split('-');
    let year = parseInt(yearStr, 10);
    let month = parseInt(monthStr, 10); // 注意：这里的 month 是 1-12
    // 根据 isNext 参数决定是加一个月还是减一个月
    if (isNext) {
        // 下一个月
        month += 1;
        if (month > 12) {
            month = 1;
            year += 1;
        }
    } else {
        // 上一个月
        month -= 1;
        if (month < 1) {
            month = 12;
            year -= 1;
        }
    }
    // 格式化新的月份值，确保月份是两位数
    const newMonthValue = `${year}-${String(month).padStart(2, '0')}`;
    // 更新 input 的值
    monthPicker.value = newMonthValue;
    // 更新月份选择器的值后，需要触发它的change事件，这样下面的日历就会重新渲染
    monthPicker.dispatchEvent(new Event('change'));
}

/**
 * 显示当前时间信息
 */
function updateCurrentDateInfo() {
    const today = new Date();
    const options = { year: 'numeric', month: 'long', day: 'numeric', weekday: 'long' };
    document.getElementById('current-date').textContent = today.toLocaleDateString('zh-CN', options);
    const firstDayOfWeek = new Date(today);
    firstDayOfWeek.setDate(today.getDate() - (today.getDay() + 6) % 7);
    const lastDayOfWeek = new Date(firstDayOfWeek);
    lastDayOfWeek.setDate(firstDayOfWeek.getDate() + 6);
    const fmt = { month: 'numeric', day: 'numeric' };
    document.getElementById('week-range').textContent = `本周：${firstDayOfWeek.toLocaleDateString('zh-CN', fmt)} - ${lastDayOfWeek.toLocaleDateString('zh-CN', fmt)}`;
}

/**
 * 根据选择的月份加载日历
 */
function renderCalendar() {
    const calendarEl = document.getElementById('calendar');
    calendarEl.innerHTML = '';

    const year = selectedDate.getFullYear();
    const month = selectedDate.getMonth();

    const firstDay = new Date(year, month, 1);
    const lastDay = new Date(year, month + 1, 0);
    const startDate = new Date(firstDay);
    // 周一为每周第一天
    const diff = (firstDay.getDay() + 6) % 7; // 计算距离周一的天数差
    startDate.setDate(firstDay.getDate() - diff);
    const today = new Date();
    const days = [];
    for (let d = new Date(startDate); d <= lastDay; d.setDate(d.getDate() + 1)) {
        days.push(new Date(d));
    }
    const weekdays = ['一', '二', '三', '四', '五', '六', '日'];
    weekdays.forEach(day => {
        const header = document.createElement('div');
        header.textContent = `周${day}`;
        header.style.fontWeight = 'bold';
        header.style.textAlign = 'center';
        calendarEl.appendChild(header);
    });
    const monthPicker = document.getElementById('month-picker').value; // 月份选择器
    const [yearStr, monthStr] = monthPicker.split('-');
    let pickerYear = parseInt(yearStr, 10);
    let pickerMonth = parseInt(monthStr, 10); // 注意：这里的 month 是 1-12
    let totalCompleted = 0; // 月总时长（已完成）
    let totalpending = 0; // 月总时长（未完成）
    let totalKcal = 0; // 月总消耗（已完成）
    days.forEach(date => {
        const dayEl = document.createElement('div');
        dayEl.className = 'calendar-day';
        if (date.getDate() === today.getDate() && date.getMonth() === today.getMonth() && date.getFullYear() === today.getFullYear()) {
            dayEl.classList.add('today');
        }
        if (date.getFullYear() === pickerYear && date.getMonth()+1 === pickerMonth) {
            const key = formatDate(date);
            const plans = currentPlans[key] || []; // 获取当天的所有计划
            const headerEl = document.createElement('header');
            const dateSpan = document.createElement('span');
            dateSpan.className = 'date';
            dateSpan.textContent = date.getDate();
            const centerContainer = createCenterContainer(key,plans);

            const weekdaySpan = document.createElement('span');
            weekdaySpan.className = 'weekday';
            weekdaySpan.textContent = ['日','一','二','三','四','五','六'][date.getDay()];
            headerEl.appendChild(dateSpan);
            headerEl.appendChild(centerContainer);
            headerEl.appendChild(weekdaySpan);
            dayEl.appendChild(headerEl);
            const addBtn = document.createElement('div');
            addBtn.className = 'add-plan-btn';
            addBtn.textContent = '+';
            addBtn.onclick = (e) => {
                e.stopPropagation();
                window.currentDateForPlan = formatDate(date);
                editingPlanKey = null; // 新增模式
                openAddPlanModal(); // 打开新增计划弹框
            };
            dayEl.appendChild(addBtn);
            const plansContainer = document.createElement('div');
            plansContainer.className = 'plans-container';
            // 遍历当天的所有计划，并创建每个计划的item元素
            plans.forEach((plan, index) => {
                let d = 0;
                const l = plan.exercises.length; // 每个计划的运动项目数
                if (plan.duration > 0){
                    if (l > 1){
                        // 因为最后一组做完后直接结束，没有休息时间，所以最后一组只算持续时间
                        d = (l - 1) * (plan.duration + plan.rest) + plan.duration + 10; // 加的10秒是一开始的准备时间
                    }else {
                        d = plan.duration + 10; // 加的10秒是一开始的准备时间
                    }
                }
                // 创建这个计划的item元素
                const planEl = document.createElement('div');
                planEl.className = `plan-item ${plan.completed ? 'completed' : ''}`;
                planEl.innerHTML = `<span class="title">${plan.title}</span>
                        <span class="kcal">${plan.kcal} 大卡</span>
                        <span class="time">${(d/60).toFixed(2)}m</span>`;
                // 禁用默认右键菜单（否则会弹出浏览器菜单）
                planEl.oncontextmenu = (e) => {
                    e.preventDefault(); // 阻止默认菜单
                    e.stopPropagation(); // 阻止冒泡
                    const key = formatDate(date);
                    const index = plans.indexOf(plan); // 获取当前计划在数组中的索引
                    if (index === -1) return;
                    // 切换 completed 状态
                    currentPlans[key][index].completed = !currentPlans[key][index].completed;
                    // 保存到 localStorage
                    localStorage.setItem('dailyPlans', JSON.stringify(currentPlans));
                    // 更新 UI
                    planEl.classList.toggle('completed', currentPlans[key][index].completed);
                    const durationSpan1 = document.getElementById(key + 'ds1');
                    const durationSpan2 = document.getElementById(key + 'ds2');
                    const duration = totalDuration(plans);
                    // 更新当天的运动时长显示
                    durationSpan1.textContent = Math.floor(duration.completed / 60);
                    durationSpan2.textContent = Math.floor(duration.pending / 60);
                    // 更新当月的运动时长显示
                    let r = Math.floor(d / 60);
                    if (currentPlans[key][index].completed){
                        totalCompleted += parseFloat(r,10);
                        totalpending -= parseFloat(r,10);
                        totalKcal += plan.kcal;
                    }else {
                        totalCompleted -= parseFloat(r,10);
                        totalpending += parseFloat(r,10);
                        totalKcal -= plan.kcal;
                    }
                    document.getElementById("month-total-completed").textContent = (totalCompleted / 60).toFixed(2); // 月总时长（已完成）
                    document.getElementById("month-total-pending").textContent = (totalpending / 60).toFixed(2); // 月总时长（未完成）
                    document.getElementById("month-total-kcal").textContent = totalKcal; // 月总时长（未完成）
                };
                // 点击计划：打开编辑弹窗
                planEl.onclick = (e) => {
                    e.stopPropagation();
                    const key = formatDate(date); // 确保使用和保存时一致的格式
                    editingPlanKey = `${key}-${index}`; // 格式：2025-09-12-0
                    window.currentDateForPlan = key;
                    openEditPlanModal(date, plan); // 打开编辑计划弹框
                };
                plansContainer.appendChild(planEl);
                if (plan.completed){
                    totalKcal += plan.kcal;
                }
            });
            dayEl.appendChild(plansContainer);
            calendarEl.appendChild(dayEl);
            const ds1 = parseFloat(document.getElementById(key + 'ds1').innerText, 10); // 每天的总时长（已完成）
            const ds2 = parseFloat(document.getElementById(key + 'ds2').innerText, 10); // 每天的总时长（未完成）
            console.log(ds1+'\t'+ds2);
            totalCompleted += ds1;
            totalpending += ds2;
        }else {
            calendarEl.appendChild(dayEl);
        }
    });
    document.getElementById("month-total-completed").textContent = (totalCompleted / 60).toFixed(2); // 月总时长（已完成）
    document.getElementById("month-total-pending").textContent = (totalpending / 60).toFixed(2); // 月总时长（未完成）
    document.getElementById("month-total-kcal").textContent = totalKcal; // 月总时长（未完成）
}

function createCenterContainer(key,plans){
    const duration = totalDuration(plans);
    // 创建中间容器用于居中显示 duration 内容
    const centerContainer = document.createElement('div');
    centerContainer.className = 'centerContainer';
    const durationSpan1 = document.createElement('span');
    const durationSpan2 = document.createElement('span');
    durationSpan1.id = key + 'ds1';
    durationSpan2.id = key + 'ds2';
    durationSpan1.style.color = '#52c41a';
    durationSpan2.style.color = '#ff4d4f';
    durationSpan1.textContent = (duration.completed / 60).toFixed(2);
    durationSpan2.textContent = (duration.pending / 60).toFixed(2);
    // 添加分隔符
    const separator = document.createElement('span');
    separator.textContent = '/';
    separator.style.color = '#999'; // 可选：设置分隔符颜色
    // 将两个 duration 和分隔符加入中间容器
    centerContainer.appendChild(durationSpan1);
    centerContainer.appendChild(separator);
    centerContainer.appendChild(durationSpan2);
    return centerContainer;
}

/**
 * 计算当天所有计划的已完成、未完成的总秒数
 */
function totalDuration(plans){
    let completedSeconds = 0;   // 已完成的总秒数
    let pendingSeconds = 0;     // 未完成的总秒数
    // 遍历当天的每个计划
    plans.forEach(plan => {
        let d = 0;
        const l = plan.exercises.length;
        if (plan.duration > 0){
            if (l > 1){
                // 因为最后一组做完后直接结束，没有休息时间，所以最后一组只算持续时间
                d = (l - 1) * (plan.duration + plan.rest) + plan.duration + 10; // 加的10秒是一开始的准备时间
            }else {
                d = plan.duration + 10; // 加的10秒是一开始的准备时间
            }
        }
        if (plan.completed) {
            completedSeconds += d;
        } else {
            pendingSeconds += d;
        }
    });
    return {
        completed: completedSeconds, // 已完成
        pending: pendingSeconds      // 未完成
    };
}

/**
 * 打开新增计划弹窗
 * @param date 当前日期
 */
function openAddPlanModal(date) {
    editingPlanKey = null;
    resetModal();
    showModal();
}

/**
 * 打开编辑计划弹窗
 * @param date 当前日期
 * @param plan 当前计划内容
 */
function openEditPlanModal(date, plan) {
    document.getElementById('plan-title').value = plan.title;
    document.getElementById('plan-exercises').value = plan.exercises.join('、');
    document.getElementById('duration').value = plan.duration;
    document.getElementById('rest').value = plan.rest;
    document.getElementById('kcal').value = plan.kcal;
    document.getElementById('ahr').value = plan.ahr;
    document.getElementById('mhr').value = plan.mhr;
    window.currentDateForPlan = formatDate(date);
    showModal(); // 显示弹窗
}

/**
 * 重置计划弹框
 */
function resetModal() {
    document.getElementById('plan-title').value = '';
    document.getElementById('plan-exercises').value = '';
    document.getElementById('duration').value = 30;
    document.getElementById('rest').value = 10;
    document.getElementById('kcal').value = 100;
    document.getElementById('ahr').value = 120;
    document.getElementById('mhr').value = 150;
}

/**
 * 显示计划弹框
 */
function showModal() {
    document.getElementById('plan-modal').classList.remove('hidden');
}

/**
 * 关闭计划弹框
 */
function closeModal() {
    document.getElementById('plan-modal').classList.add('hidden');
}

/**
 * 加载计划标题下拉
 */
function populateTitleSuggestions() {
    const datalist = document.getElementById('title-suggestions');
    suggestedTitles.forEach(title => {
        const option = document.createElement('option');
        option.value = title;
        datalist.appendChild(option);
    });
}

/**
 * 开始运动
 */
function startTimer() {
    // 开始运动时，不管有没有更改计划内容，都先保存计划
    if (!saveCurrentPlan()) return;
    const dateKey = window.currentDateForPlan;
    const plans = currentPlans[dateKey] || [];
    let executingPlan;
    if (editingPlanKey) {
        const parts = editingPlanKey.split('-');
        const index = parseInt(parts.pop(), 10);
        executingPlan = plans[index];
    } else {
        executingPlan = plans[plans.length - 1];
    }
    if (!executingPlan) return;
    // 确保 exercises 是数组
    localStorage.setItem('currentExercisePlan', JSON.stringify({
        ...executingPlan,
        dateKey,
        planIndex: editingPlanKey ? parseInt(editingPlanKey.split('-').pop(), 10) : plans.length - 1
    }));
    window.open('timer.html', '_blank');
}

/**
 * 保存计划弹框
 * @returns {boolean} 返回是否保存成功
 */
function saveCurrentPlan() {
    currentPlans = JSON.parse(localStorage.getItem('dailyPlans')) || {};
    const title = document.getElementById('plan-title').value.trim();
    const exercisesText = document.getElementById('plan-exercises').value.trim(); // 字符串："深蹲、俯卧撑"
    const duration = parseInt(document.getElementById('duration').value);
    const rest = parseInt(document.getElementById('rest').value);
    const kcal = parseInt(document.getElementById('kcal').value);
    const ahr = parseInt(document.getElementById('ahr').value);
    const mhr = parseInt(document.getElementById('mhr').value);
    if (!title || !exercisesText) {
        messageplugin({ message: "请填写完整信息！", type: "error" });
        return false;
    }
    // 必须将字符串拆分为数组
    const exercises = exercisesText.split('、').map(e => e.trim()).filter(e => e);
    if (exercises.length === 0) {
        messageplugin({ message: "请输入有效的运动项目！", type: "error" });
        return false;
    }
    const dateKey = window.currentDateForPlan;
    if (!dateKey) {
        messageplugin({ message: "日期信息丢失！", type: "error" });
        return false;
    }
    const plan = {
        title,
        exercises,  // 确保是数组，如 ['深蹲', '俯卧撑']
        duration,
        rest,
        kcal,
        ahr,
        mhr,
        completed: false
    };
    if (!currentPlans[dateKey]) {
        currentPlans[dateKey] = [];
    }
    if (editingPlanKey) {
        const parts = editingPlanKey.split('-');
        const indexStr = parts.pop();
        const key = parts.join('-');
        const index = parseInt(indexStr, 10);
        plan.completed = currentPlans[dateKey][index].completed;
        if (!isNaN(index) && index >= 0 && currentPlans[key] && index < currentPlans[key].length) {
            currentPlans[key][index] = plan; // 替换整个计划对象
        } else {
            messageplugin({ message: "索引无效！", type: "error" });
            return false;
        }
    } else {
        currentPlans[dateKey].push(plan);
    }
    localStorage.setItem('dailyPlans', JSON.stringify(currentPlans));
    closeModal();
    renderCalendar();
    dayTotalDuration(dateKey); // 如果当天运动时长超过了60分钟，提示注意休息
    consecutiveDays(dateKey); // 从这天开始往前计算连续运动的天数，大于等于5天，提示注意休息
    return true;
}

/**
 * 计算日总计时长
 * @param dateKey 指定的某一天
 */
function dayTotalDuration(dateKey){
    // 获取当天所有的计划，并计算总时长（duration+rest），单位转为分钟
    const todayPlans = currentPlans[dateKey] || [];
    const total = totalDuration(todayPlans);
    const totalMinutes = ((total.completed + total.pending)/60).toFixed(2);
    if (totalMinutes >= 60){
        messageplugin({ message: `你 ${dateKey} 这天的总运动时长（含休息）已达 ${totalMinutes} 分钟，注意休息哦`, type: "warning",duration:5000});
    }
}

/**
 * 计算连续运动天数
 * @param dateKey 从某一天开始往前计算连续的天数
 */
function consecutiveDays(dateKey){
    const allDates = Object.keys(currentPlans).filter(date => currentPlans[date].length > 0);
    const sortedDates = allDates
        .map(d => new Date(d)) // 假设 dateKey 格式是 'YYYY-MM-DD'
        .sort((a, b) => b - a); // 降序：最新日期在前
    const today = new Date(dateKey); // 当前操作的日期
    let consecutiveDays = 0; // 记录连续运动天数
    let currentDate = new Date(today);
    // 向前检查连续天数
    while (consecutiveDays < 100) { // 防止死循环，最多查100天
        const dateString = currentDate.toISOString().split('T')[0]; // 转成 'YYYY-MM-DD'
        const todayPlans = currentPlans[dateString] || [];
        const total = totalDuration(todayPlans);
        const totalMinutes = ((total.completed + total.pending)/60).toFixed(2);
        console.log(dateString + '\t' +totalMinutes);
        // 检查这一天是否有计划并且这天的运动总时长超过了20分钟则视为连续的一天
        if (totalMinutes >= 21 && allDates.includes(dateString)) {
            consecutiveDays++;
        } else {
            break; // 中断连续
        }
        // 前一天
        currentDate.setDate(currentDate.getDate() - 1);
    }
    // 如果连续天数 >= 5，弹出提示
    if (consecutiveDays >= 4) {
        messageplugin({ message: `你已经连续运动 ${consecutiveDays} 天辣🎉，太厉害辣！👍很棒！👏，但是也要注意休息哦`, type: "warning",duration:5000});
    }
}

/**
 * 删除计划
 * @returns {boolean}
 */
function deletePlan(){
    const dateKey = window.currentDateForPlan;
    if (!dateKey) {
        messageplugin({ message: "日期信息丢失！", type: "error" });
        return false;
    }
    const parts = editingPlanKey.split('-');
    const indexStr = parts.pop();
    const key = parts.join('-');
    const index = parseInt(indexStr, 10);
    currentPlans[key].splice(index, 1);
    localStorage.setItem('dailyPlans', JSON.stringify(currentPlans));
    closeModal();
    renderCalendar();
}

/**
 * 导出excel数据
 * @param isExportAll 是否全部导出 true 全部导出 false 只导出本月数据
 */
function exportExcel(isExportAll) {
    // 1. 准备数据（转换为表格行）
    const worksheetData = [];
    // 添加表头
    worksheetData.push(['日期', '运动计划', '运动内容', '每项运动时长(秒)', '休息时长(秒)', '总运动时长(分钟)','平均心率','最大心率','总消耗(kcal)', '完成状态']);
    let sortedDates;
    if (isExportAll){
        // 获取所有日期 key，并按升序排序
        sortedDates = Object.keys(currentPlans)
            .filter(dateKey => currentPlans.hasOwnProperty(dateKey))
            .sort(); // 对 'YYYY-MM-DD' 格式天然有效
    }else {
        const calendarEl = document.getElementById('month-picker').value;
        // 获取当前月的所有日期key，并按升序排序
        sortedDates = Object.keys(currentPlans)
            .filter(dateKey => currentPlans.hasOwnProperty(dateKey) && dateKey.startsWith(calendarEl))
            .sort(); // 对 'YYYY-MM-DD' 格式天然有效
    }
    for (const index in sortedDates) {
        const dateKey = sortedDates[index];
        if (!currentPlans.hasOwnProperty(dateKey)) continue;
        const plans = currentPlans[dateKey];
        // 检查是否是数组
        if (!Array.isArray(plans)) continue;
        createExcelDataRow(dateKey,plans,worksheetData); // 全部数据都创建数据行
    }
    // 2. 使用 XLSX 创建工作簿和工作表
    const workbook = XLSX.utils.book_new();
    const worksheet = XLSX.utils.aoa_to_sheet(worksheetData);
    // 3. 设置列宽（可选）
    worksheet['!cols'] = [
        { wch: 15 }, // 日期
        { wch: 15 }, // 运动计划
        { wch: 50 }, // 运动内容
        { wch: 20 }, // 每项运动时长
        { wch: 15 }, // 休息时长
        { wch: 20 }, // 总运动时长
        { wch: 10 }, // 平均心率
        { wch: 10 }, // 最大心率
        { wch: 20 }, // 总消耗
        { wch: 10 }  // 完成状态
    ];
    // 4. 将工作表添加到工作簿
    XLSX.utils.book_append_sheet(workbook, worksheet, '训练计划');
    // 5. 导出文件
    XLSX.writeFile(workbook, `训练计划_${new Date().toISOString().slice(0, 10)}.xlsx`);
    // exportJson();
}

/**
 * 创建表格数据行
 * @param dateKey
 * @param plans
 * @param worksheetData
 */
function createExcelDataRow(dateKey,plans,worksheetData){
    // 每个计划项生成一行
    plans.forEach(plan => {
        const {title, exercises, duration, rest,ahr,mhr,kcal, completed} = plan;
        // 计算总运动时长（分钟）：(duration + rest) 的总和，单位转为分钟
        // 注意：duration 和 rest 是每项的秒数，这里假设每个动作都执行一次
        // 所以总时长 = (duration + rest) 秒，再转为分钟
        const totalSeconds = duration + rest;
        const totalMinutes = totalSeconds / 60; // 转为分钟（保留小数）
        // 运动内容转为字符串，用顿号分隔
        const exercisesStr = Array.isArray(exercises) ? exercises.join('、') : '';
        // 完成状态转为中文
        const completedStr = completed ? '已完成' : '未完成';
        // 添加一行
        worksheetData.push([
            dateKey,
            title,
            exercisesStr,
            duration,
            rest,
            parseFloat(totalMinutes.toFixed(2)), // 保留两位小数
            ahr,
            mhr,
            kcal,
            completedStr
        ]);
    });
}

/**
 * 导出json数据
 */
function exportJson(){
    const data = localStorage.getItem('dailyPlans');
    // 2. 解析 JSON（验证数据有效性）
    const jsonData = JSON.parse(data);
    // 3. 创建 Blob 对象（JSON 数据作为文件内容）
    const blob = new Blob([JSON.stringify(jsonData, null, 2)], {
        type: 'application/json;charset=utf-8'
    });
    // 4. 创建下载链接
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = 'dailyPlans_' + new Date().toISOString().slice(0, 10) + '.json'; // 带日期的文件名
    a.style.display = 'none';
    // 5. 添加到页面并触发点击
    document.body.appendChild(a);
    a.click();
    // 6. 清理：移除元素和释放 URL
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
}

/**
 * 清除localStorage里的数据
 * @param isClearAll 是否清除全部数据 true 清除全部 false 清除本月
 */
function clearData(isClearAll){
    if (Object.keys(currentPlans).length === 0) {
        messageplugin({ message: "当前没有训练计划数据，无需删除。", type: "warning" });
        return;
    }
    if (isClearAll){
        const confirmed = confirm(
            `是否清除全部训练计划？\n\n` +
            `⚠️ 此操作不可恢复！清除之前请先将数据导出！`
        );
        if (confirmed){
            // 清除全部数据
            currentPlans = {}; // currentPlans 重置为空对象
            localStorage.setItem('dailyPlans', JSON.stringify(currentPlans));
            renderCalendar();
            messageplugin({ message: "训练计划数据已全部清除！", type: "success" });
        }
    }else {
        const calendarEl = document.getElementById('month-picker').value;
        const keysToRemove = Object.keys(currentPlans).filter(key => key.startsWith(calendarEl));
        if (keysToRemove.length === 0){
            messageplugin({ message: "当前没有训练计划数据，无需删除。", type: "warning" });
            return;
        }
        const confirmed = confirm(
            `是否删除本月的训练计划？\n\n` +
            `⚠️ 此操作不可恢复！清除之前请先将数据导出！`
        );
        if (confirmed){
            keysToRemove.forEach(key => delete currentPlans[key]);
            localStorage.setItem('dailyPlans', JSON.stringify(currentPlans));
            messageplugin({ message: `${calendarEl} 的数据已清除！`, type: "success" });
            localStorage.setItem('dailyPlans', JSON.stringify(currentPlans));
            renderCalendar();
        }
    }
}

// 工具函数
function formatDate(date) {
    const y = date.getFullYear();
    const m = String(date.getMonth() + 1).padStart(2, '0');
    const d = String(date.getDate()).padStart(2, '0');
    return `${y}-${m}-${d}`;
}